/**
 * c08_integer_range - 整数范围：最大值、最小值与范围操作
 * 
 * 这是《Rust基础数据类型实战Cookbook》系列的第8个案例
 * 
 * 学习目标：
 * 1. 掌握各种整数类型的最大值和最小值
 * 2. 理解整数范围的数学概念和实际应用  
 * 3. 学习范围检查、边界处理等常见操作
 * 4. 掌握范围相关的实用工具函数
 * 5. 了解范围操作在实际开发中的应用场景
 * 
 * 主要内容：
 * - 整数类型的边界值（MIN/MAX常量）
 * - 范围表示和范围操作
 * - 边界值处理和溢出检测
 * - 范围验证和夹持操作
 * - 数学范围运算
 * - 实际应用案例
 */

// 注意：std::ops::RangeInclusive 在此项目中未直接使用，但在其他范围操作中很有用

fn main() {
    println!("=== Rust 整数范围操作示例 ===\n");

    // 1. 整数类型的边界值
    demonstrate_integer_bounds();
    
    // 2. 范围表示和基本操作
    demonstrate_range_operations();
    
    // 3. 边界值检查和处理
    demonstrate_boundary_checks();
    
    // 4. 范围验证和夹持操作
    demonstrate_range_validation();
    
    // 5. 数学范围运算
    demonstrate_mathematical_ranges();
    
    // 6. 实际应用案例
    demonstrate_practical_applications();
    
    println!("\n=== 总结 ===");
    println!("整数范围操作是编程中的基础概念，掌握这些技能对于：");
    println!("- 数据验证和边界检查");
    println!("- 算法实现和优化");
    println!("- 安全编程和错误预防");
    println!("- 数值计算和范围控制");
    println!("都具有重要意义。");
}

/**
 * 演示各种整数类型的边界值
 * 
 * 重点知识：
 * - 每种整数类型都有固定的取值范围
 * - MIN 和 MAX 常量提供边界值信息
 * - 有符号数和无符号数的范围差异
 * - 不同位宽的容量差异
 */
fn demonstrate_integer_bounds() {
    println!("1. 整数类型的边界值");
    println!("   每种整数类型都有固定的最小值和最大值");
    
    // 1.1 8位整数类型的范围
    println!("\n1.1 8位整数类型 (1字节)");
    println!("有符号 i8:");
    println!("  最小值: {} (二进制: {:08b})", i8::MIN, i8::MIN as u8);
    println!("  最大值: {} (二进制: {:08b})", i8::MAX, i8::MAX as u8);
    println!("  取值范围: {} 到 {} (共 {} 个不同值)", 
             i8::MIN, i8::MAX, (i8::MAX as i16) - (i8::MIN as i16) + 1);
    
    println!("无符号 u8:");
    println!("  最小值: {} (二进制: {:08b})", u8::MIN, u8::MIN);
    println!("  最大值: {} (二进制: {:08b})", u8::MAX, u8::MAX);
    println!("  取值范围: {} 到 {} (共 {} 个不同值)", 
             u8::MIN, u8::MAX, (u8::MAX as u16) + 1);
    
    // 1.2 16位整数类型的范围
    println!("\n1.2 16位整数类型 (2字节)");
    println!("有符号 i16:");
    println!("  最小值: {} (十六进制: 0x{:04X})", i16::MIN, i16::MIN as u16);
    println!("  最大值: {} (十六进制: 0x{:04X})", i16::MAX, i16::MAX as u16);
    println!("  容量: 2^16 = {} 个不同值", 1u32 << 16);
    
    println!("无符号 u16:");
    println!("  最小值: {} (十六进制: 0x{:04X})", u16::MIN, u16::MIN);
    println!("  最大值: {} (十六进制: 0x{:04X})", u16::MAX, u16::MAX);
    
    // 1.3 32位整数类型的范围
    println!("\n1.3 32位整数类型 (4字节) - 最常用");
    println!("有符号 i32:");
    println!("  最小值: {} (约 -21亿)", i32::MIN);
    println!("  最大值: {} (约 21亿)", i32::MAX);
    println!("  容量: 2^32 = {} 个不同值", 1u64 << 32);
    
    println!("无符号 u32:");
    println!("  最小值: {}", u32::MIN);
    println!("  最大值: {} (约 43亿)", u32::MAX);
    
    // 1.4 64位整数类型的范围
    println!("\n1.4 64位整数类型 (8字节) - 大数运算");
    println!("有符号 i64:");
    println!("  最小值: {} (约 -922万万亿)", i64::MIN);
    println!("  最大值: {} (约 922万万亿)", i64::MAX);
    
    println!("无符号 u64:");
    println!("  最小值: {}", u64::MIN);
    println!("  最大值: {} (约 1844万万亿)", u64::MAX);
    
    // 1.5 平台相关的指针大小整数
    println!("\n1.5 平台相关的指针大小整数");
    println!("有符号 isize (当前平台 {} 位):", std::mem::size_of::<isize>() * 8);
    println!("  最小值: {}", isize::MIN);
    println!("  最大值: {}", isize::MAX);
    
    println!("无符号 usize (当前平台 {} 位):", std::mem::size_of::<usize>() * 8);
    println!("  最小值: {}", usize::MIN);
    println!("  最大值: {}", usize::MAX);
    
    // 1.6 边界值的实际意义
    println!("\n1.6 边界值的实际意义");
    println!("数据类型选择建议:");
    println!("  u8:  RGB颜色值(0-255)、年龄、百分比等");
    println!("  i16: 温度(-32768°C 到 32767°C)、小范围坐标等");
    println!("  u16: 端口号(0-65535)、小范围ID等");
    println!("  i32: 日期时间戳、大部分计数器、坐标等");
    println!("  u32: 大范围ID、无符号计数器等");
    println!("  i64: 文件大小、高精度时间戳、大数运算等");
    println!("  u64: 超大范围ID、科学计算等");
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示范围表示和基本操作
 * 
 * 重点知识：
 * - Range 和 RangeInclusive 的区别
 * - 范围的创建和使用方法
 * - 范围的遍历和检查
 * - 范围的数学操作
 */
fn demonstrate_range_operations() {
    println!("\n2. 范围表示和基本操作");
    println!("   Rust 提供多种范围表示方法");
    
    // 2.1 基本范围类型
    println!("\n2.1 基本范围类型");
    
    // 半开区间范围 [start, end)
    let half_open_range = 1..10;  // 1, 2, 3, ..., 9 (不包含10)
    println!("半开区间 1..10:");
    print!("  包含的值: ");
    for value in half_open_range.clone() {
        print!("{} ", value);
    }
    println!();
    println!("  起始值: {}", half_open_range.start);
    println!("  结束值: {} (不包含)", half_open_range.end);
    println!("  长度: {}", half_open_range.len());
    
    // 闭区间范围 [start, end]
    let closed_range = 1..=10;  // 1, 2, 3, ..., 10 (包含10)
    println!("\n闭区间 1..=10:");
    print!("  包含的值: ");
    for value in closed_range.clone() {
        print!("{} ", value);
    }
    println!();
    println!("  起始值: {}", closed_range.start());
    println!("  结束值: {} (包含)", closed_range.end());
    
    // 2.2 范围检查操作
    println!("\n2.2 范围检查操作");
    let test_range = 10..=20;
    let test_values = [5, 10, 15, 20, 25];
    
    println!("范围 10..=20 的包含性检查:");
    for value in test_values {
        let contains = test_range.contains(&value);
        println!("  {} 在范围内: {}", value, contains);
    }
    
    // 2.3 无界范围
    println!("\n2.3 无界范围");
    let values = vec![1, 5, 10, 15, 20, 25, 30];
    
    // 从某个值开始到结尾
    println!("从索引2开始到结尾的元素 (2..):");
    for (i, value) in values[2..].iter().enumerate() {
        println!("  索引 {}: {}", i + 2, value);
    }
    
    // 从开始到某个值
    println!("从开始到索引4的元素 (..=4):");
    for (i, value) in values[..=4].iter().enumerate() {
        println!("  索引 {}: {}", i, value);
    }
    
    // 2.4 范围的数学性质
    println!("\n2.4 范围的数学性质");
    let range1 = 5..15;
    let range2 = 10..20;
    
    println!("范围1: {}..{} (长度: {})", range1.start, range1.end, range1.len());
    println!("范围2: {}..{} (长度: {})", range2.start, range2.end, range2.len());
    
    // 检查范围重叠
    let overlap_start = range1.start.max(range2.start);
    let overlap_end = range1.end.min(range2.end);
    let has_overlap = overlap_start < overlap_end;
    
    println!("范围重叠: {}", has_overlap);
    if has_overlap {
        println!("重叠部分: {}..{} (长度: {})", 
                overlap_start, overlap_end, overlap_end - overlap_start);
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示边界值检查和处理
 * 
 * 重点知识：
 * - 边界值的特殊性和重要性
 * - 上下边界的检查方法
 * - 边界溢出的检测和处理
 * - 安全的边界操作
 */
fn demonstrate_boundary_checks() {
    println!("\n3. 边界值检查和处理");
    println!("   边界值是程序中最容易出错的地方");
    
    // 3.1 基本边界检查
    println!("\n3.1 基本边界检查");
    
    // 检查是否接近边界
    fn check_boundary_proximity<T>(value: T, min_val: T, max_val: T, threshold: T) -> String 
    where 
        T: Copy + PartialOrd + std::ops::Sub<Output = T> + std::ops::Add<Output = T> + std::fmt::Display
    {
        if value <= min_val + threshold {
            format!("{} 接近下边界 {}", value, min_val)
        } else if value >= max_val - threshold {
            format!("{} 接近上边界 {}", value, max_val)
        } else {
            format!("{} 在安全范围内", value)
        }
    }
    
    let test_values = [1, 10, 50, 90, 100];
    let min_val = 0;
    let max_val = 100;
    let threshold = 10;
    
    println!("边界检查 (范围: {}-{}, 阈值: {}):", min_val, max_val, threshold);
    for value in test_values {
        println!("  {}", check_boundary_proximity(value, min_val, max_val, threshold));
    }
    
    // 3.2 溢出检测
    println!("\n3.2 溢出检测");
    
    // 加法溢出检测
    let a: u8 = 200;
    let b: u8 = 100;
    
    println!("检查 u8 加法溢出: {} + {}", a, b);
    match a.checked_add(b) {
        Some(result) => println!("  结果: {}", result),
        None => println!("  溢出！超出 u8 的最大值 {}", u8::MAX),
    }
    
    // 减法下溢检测
    let c: u8 = 50;
    let d: u8 = 100;
    
    println!("检查 u8 减法下溢: {} - {}", c, d);
    match c.checked_sub(d) {
        Some(result) => println!("  结果: {}", result),
        None => println!("  下溢！小于 u8 的最小值 {}", u8::MIN),
    }
    
    // 乘法溢出检测
    let e: i16 = 200;
    let f: i16 = 200;
    
    println!("检查 i16 乘法溢出: {} × {}", e, f);
    match e.checked_mul(f) {
        Some(result) => println!("  结果: {}", result),
        None => println!("  溢出！超出 i16 的范围 {} 到 {}", i16::MIN, i16::MAX),
    }
    
    // 3.3 边界值的饱和处理
    println!("\n3.3 边界值的饱和处理");
    println!("饱和算术：结果限制在类型的有效范围内");
    
    let values = [250u8, 10u8, 5u8];
    let add_val = 20u8;
    
    println!("饱和加法示例 (加数: {}):", add_val);
    for value in values {
        let saturating_result = value.saturating_add(add_val);
        let normal_would_be = (value as u16) + (add_val as u16);
        
        println!("  {} + {} = {} (正常结果会是 {})", 
                value, add_val, saturating_result, normal_would_be);
        
        if normal_would_be > u8::MAX as u16 {
            println!("    → 饱和到最大值 {}", u8::MAX);
        }
    }
    
    // 3.4 自定义边界检查函数
    println!("\n3.4 自定义边界检查函数");
    
    // 检查值是否在边界上
    fn is_at_boundary<T: PartialEq + Copy>(value: T, min_val: T, max_val: T) -> &'static str {
        if value == min_val {
            "在最小值边界"
        } else if value == max_val {
            "在最大值边界" 
        } else {
            "不在边界"
        }
    }
    
    let boundary_tests = [i8::MIN, -1, 0, 1, i8::MAX];
    println!("i8 边界检查:");
    for value in boundary_tests {
        println!("  {}: {}", value, is_at_boundary(value, i8::MIN, i8::MAX));
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示范围验证和夹持操作
 * 
 * 重点知识：
 * - 输入验证和范围限制
 * - 夹持操作的实现和应用
 * - 数据清理和标准化
 * - 容错机制的设计
 */
fn demonstrate_range_validation() {
    println!("\n4. 范围验证和夹持操作");
    println!("   在实际应用中确保数据在有效范围内");
    
    // 4.1 基本夹持函数
    println!("\n4.1 基本夹持函数 (Clamp)");
    
    // 泛型夹持函数
    fn clamp<T: PartialOrd + Copy>(value: T, min_val: T, max_val: T) -> T {
        if value < min_val {
            min_val
        } else if value > max_val {
            max_val
        } else {
            value
        }
    }
    
    let test_values = [-10, -5, 0, 5, 10, 15, 20, 25, 30];
    let min_range = 0;
    let max_range = 20;
    
    println!("夹持到范围 [{}..{}]:", min_range, max_range);
    for value in test_values {
        let clamped = clamp(value, min_range, max_range);
        let status = if value < min_range {
            "低于范围 → 调整到最小值"
        } else if value > max_range {
            "超过范围 → 调整到最大值"
        } else {
            "在范围内 → 保持不变"
        };
        println!("  {} → {} ({})", value, clamped, status);
    }
    
    // 4.2 范围验证函数
    println!("\n4.2 范围验证函数");
    
    // 验证结果类型
    #[derive(Debug)]
    enum ValidationResult<T> {
        Valid(T),
        TooLow { value: T, min: T },
        TooHigh { value: T, max: T },
    }
    
    // 范围验证函数
    fn validate_range<T: PartialOrd + Copy>(value: T, min_val: T, max_val: T) -> ValidationResult<T> {
        if value < min_val {
            ValidationResult::TooLow { value, min: min_val }
        } else if value > max_val {
            ValidationResult::TooHigh { value, max: max_val }
        } else {
            ValidationResult::Valid(value)
        }
    }
    
    println!("年龄验证示例 (有效范围: 0-150):");
    let age_tests = [-5, 0, 25, 65, 100, 150, 200];
    
    for age in age_tests {
        match validate_range(age, 0, 150) {
            ValidationResult::Valid(val) => println!("  年龄 {}: 有效", val),
            ValidationResult::TooLow { value, min } => {
                println!("  年龄 {}: 无效，小于最小值 {}", value, min);
            },
            ValidationResult::TooHigh { value, max } => {
                println!("  年龄 {}: 无效，大于最大值 {}", value, max);
            },
        }
    }
    
    // 4.3 百分比处理
    println!("\n4.3 百分比处理");
    
    // 百分比夹持和格式化
    fn format_percentage(value: f32) -> String {
        let clamped = clamp(value, 0.0, 100.0);
        if clamped != value {
            format!("{}% (原值 {}% 超出范围，已调整)", clamped, value)
        } else {
            format!("{}%", clamped)
        }
    }
    
    let percentage_tests = [-10.0, 0.0, 25.5, 50.0, 100.0, 120.0];
    println!("百分比处理:");
    for pct in percentage_tests {
        println!("  {}", format_percentage(pct));
    }
    
    // 4.4 RGB颜色值处理
    println!("\n4.4 RGB颜色值处理");
    
    // RGB颜色结构
    #[derive(Debug, Clone, Copy)]
    struct Color {
        r: u8,
        g: u8, 
        b: u8,
    }
    
    impl Color {
        // 从浮点值创建颜色（0.0-1.0范围）
        fn from_float(r: f32, g: f32, b: f32) -> Self {
            Color {
                r: clamp((r * 255.0) as i32, 0, 255) as u8,
                g: clamp((g * 255.0) as i32, 0, 255) as u8,
                b: clamp((b * 255.0) as i32, 0, 255) as u8,
            }
        }
        
        // 调整亮度（保持在有效范围内）
        fn adjust_brightness(&self, delta: i16) -> Self {
            Color {
                r: clamp(self.r as i16 + delta, 0, 255) as u8,
                g: clamp(self.g as i16 + delta, 0, 255) as u8,
                b: clamp(self.b as i16 + delta, 0, 255) as u8,
            }
        }
        
        // 转换为十六进制字符串
        fn to_hex(&self) -> String {
            format!("#{:02X}{:02X}{:02X}", self.r, self.g, self.b)
        }
    }
    
    println!("RGB颜色处理:");
    
    // 从超范围浮点值创建颜色
    let colors = [
        (-0.1, 0.5, 1.2),  // 包含超范围值
        (0.2, 0.8, 0.6),   // 正常值
        (1.0, 1.0, 1.0),   // 边界值
    ];
    
    for (r, g, b) in colors {
        let color = Color::from_float(r, g, b);
        println!("  ({:.1}, {:.1}, {:.1}) → RGB({}, {}, {}) → {}", 
                r, g, b, color.r, color.g, color.b, color.to_hex());
    }
    
    // 亮度调整示例
    let base_color = Color { r: 128, g: 64, b: 192 };
    println!("\n亮度调整示例 (基色: RGB({}, {}, {})):", 
             base_color.r, base_color.g, base_color.b);
    
    let brightness_deltas = [-100, -50, 0, 50, 100, 150];
    for delta in brightness_deltas {
        let adjusted = base_color.adjust_brightness(delta);
        println!("  亮度{:+3}: RGB({:3}, {:3}, {:3}) → {}", 
                delta, adjusted.r, adjusted.g, adjusted.b, adjusted.to_hex());
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示数学范围运算
 * 
 * 重点知识：
 * - 范围的数学运算
 * - 集合运算（并集、交集、差集）
 * - 范围分割和合并
 * - 数学分析中的应用
 */
fn demonstrate_mathematical_ranges() {
    println!("\n5. 数学范围运算");
    println!("   范围的数学运算和集合操作");
    
    // 5.1 范围集合运算
    println!("\n5.1 范围集合运算");
    
    // 简化的范围结构用于演示
    #[derive(Debug, Clone, Copy, PartialEq)]
    struct SimpleRange {
        start: i32,
        end: i32,  // 包含端点
    }
    
    impl SimpleRange {
        fn new(start: i32, end: i32) -> Self {
            SimpleRange { start, end }
        }
        
        // 检查是否包含某个值
        fn contains(&self, value: i32) -> bool {
            value >= self.start && value <= self.end
        }
        
        // 检查是否与另一个范围重叠
        fn overlaps(&self, other: &SimpleRange) -> bool {
            self.start <= other.end && other.start <= self.end
        }
        
        // 计算与另一个范围的交集
        fn intersection(&self, other: &SimpleRange) -> Option<SimpleRange> {
            let start = self.start.max(other.start);
            let end = self.end.min(other.end);
            
            if start <= end {
                Some(SimpleRange::new(start, end))
            } else {
                None
            }
        }
        
        // 计算与另一个范围的并集（仅当重叠或相邻时）
        fn union(&self, other: &SimpleRange) -> Option<SimpleRange> {
            if self.overlaps(other) || self.end + 1 == other.start || other.end + 1 == self.start {
                Some(SimpleRange::new(
                    self.start.min(other.start),
                    self.end.max(other.end)
                ))
            } else {
                None
            }
        }
        
        // 长度
        fn len(&self) -> i32 {
            self.end - self.start + 1
        }
    }
    
    let range1 = SimpleRange::new(5, 15);
    let range2 = SimpleRange::new(10, 20);
    let range3 = SimpleRange::new(25, 35);
    
    println!("范围1: [{}, {}] (长度: {})", range1.start, range1.end, range1.len());
    println!("范围2: [{}, {}] (长度: {})", range2.start, range2.end, range2.len());
    println!("范围3: [{}, {}] (长度: {})", range3.start, range3.end, range3.len());
    
    // 使用 contains 方法进行点包含检查
    println!("\n点包含检查:");
    let test_points = [0, 5, 10, 15, 20, 25, 30, 35, 40];
    for point in test_points {
        let in_range1 = range1.contains(point);
        let in_range2 = range2.contains(point);
        let in_range3 = range3.contains(point);
        
        if in_range1 || in_range2 || in_range3 {
            let mut contained_in = Vec::new();
            if in_range1 { contained_in.push("范围1"); }
            if in_range2 { contained_in.push("范围2"); }
            if in_range3 { contained_in.push("范围3"); }
            println!("  点 {} 包含在: {}", point, contained_in.join(", "));
        }
    }
    
    // 重叠检查
    println!("\n重叠检查:");
    println!("  范围1 和 范围2: {}", range1.overlaps(&range2));
    println!("  范围1 和 范围3: {}", range1.overlaps(&range3));
    println!("  范围2 和 范围3: {}", range2.overlaps(&range3));
    
    // 交集计算
    println!("\n交集计算:");
    match range1.intersection(&range2) {
        Some(intersection) => println!("  范围1 ∩ 范围2: [{}, {}] (长度: {})", 
                                     intersection.start, intersection.end, intersection.len()),
        None => println!("  范围1 ∩ 范围2: 空集"),
    }
    
    match range1.intersection(&range3) {
        Some(intersection) => println!("  范围1 ∩ 范围3: [{}, {}]", 
                                     intersection.start, intersection.end),
        None => println!("  范围1 ∩ 范围3: 空集"),
    }
    
    // 并集计算
    println!("\n并集计算:");
    match range1.union(&range2) {
        Some(union) => println!("  范围1 ∪ 范围2: [{}, {}] (长度: {})", 
                               union.start, union.end, union.len()),
        None => println!("  范围1 ∪ 范围2: 不相邻，无法合并为单一范围"),
    }
    
    match range1.union(&range3) {
        Some(union) => println!("  范围1 ∪ 范围3: [{}, {}]", union.start, union.end),
        None => println!("  范围1 ∪ 范围3: 不相邻，无法合并为单一范围"),
    }
    
    // 5.2 范围分割操作
    println!("\n5.2 范围分割操作");
    
    let main_range = SimpleRange::new(1, 100);
    let split_points = [25, 50, 75];
    
    println!("将范围 [{}, {}] 按点 {:?} 分割:", 
             main_range.start, main_range.end, split_points);
    
    let mut current_start = main_range.start;
    for (i, &split_point) in split_points.iter().enumerate() {
        if split_point > current_start && split_point <= main_range.end {
            let segment = SimpleRange::new(current_start, split_point - 1);
            println!("  段{}: [{}, {}] (长度: {})", 
                    i + 1, segment.start, segment.end, segment.len());
            current_start = split_point;
        }
    }
    
    // 最后一段
    if current_start <= main_range.end {
        let final_segment = SimpleRange::new(current_start, main_range.end);
        println!("  最后段: [{}, {}] (长度: {})", 
                final_segment.start, final_segment.end, final_segment.len());
    }
    
    // 5.3 范围的数学统计
    println!("\n5.3 范围的数学统计");
    
    let ranges = [
        SimpleRange::new(10, 20),
        SimpleRange::new(15, 30), 
        SimpleRange::new(25, 40),
        SimpleRange::new(50, 60),
    ];
    
    println!("范围集合统计:");
    for (i, range) in ranges.iter().enumerate() {
        println!("  范围{}: [{}, {}] 长度={}", i+1, range.start, range.end, range.len());
    }
    
    // 计算总覆盖范围
    let min_start = ranges.iter().map(|r| r.start).min().unwrap();
    let max_end = ranges.iter().map(|r| r.end).max().unwrap();
    let total_span = max_end - min_start + 1;
    
    println!("\n集合统计:");
    println!("  最小起始点: {}", min_start);
    println!("  最大结束点: {}", max_end);
    println!("  总跨度: {} (从 {} 到 {})", total_span, min_start, max_end);
    
    // 计算实际覆盖的点
    let mut covered_points = std::collections::HashSet::new();
    for range in &ranges {
        for point in range.start..=range.end {
            covered_points.insert(point);
        }
    }
    
    println!("  实际覆盖点数: {}", covered_points.len());
    println!("  覆盖率: {:.1}%", (covered_points.len() as f32 / total_span as f32) * 100.0);
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示实际应用案例
 * 
 * 重点知识：
 * - 范围操作在实际项目中的应用
 * - 性能优化和算法实现
 * - 数据验证和用户界面
 * - 游戏开发中的碰撞检测
 */
fn demonstrate_practical_applications() {
    println!("\n6. 实际应用案例");
    println!("   范围操作在实际开发中的具体应用");
    
    // 6.1 时间段管理系统
    println!("\n6.1 时间段管理系统");
    
    #[derive(Debug, Clone, Copy)]
    struct TimeSlot {
        start_hour: u8,   // 24小时制
        duration: u8,     // 小时数
    }
    
    impl TimeSlot {
        fn new(start_hour: u8, duration: u8) -> Result<Self, String> {
            if start_hour >= 24 {
                return Err("开始时间不能超过23点".to_string());
            }
            if duration == 0 {
                return Err("时间段不能为0小时".to_string());
            }
            if start_hour as u16 + duration as u16 > 24 {
                return Err("时间段不能跨越午夜".to_string());
            }
            
            Ok(TimeSlot { start_hour, duration })
        }
        
        fn end_hour(&self) -> u8 {
            self.start_hour + self.duration
        }
        
        fn overlaps(&self, other: &TimeSlot) -> bool {
            let self_end = self.end_hour();
            let other_end = other.end_hour();
            
            // 检查时间段重叠
            self.start_hour < other_end && other.start_hour < self_end
        }
        
        fn format(&self) -> String {
            format!("{:02}:00-{:02}:00 ({} 小时)", 
                   self.start_hour, self.end_hour(), self.duration)
        }
    }
    
    let time_slots = [
        TimeSlot::new(9, 2).unwrap(),   // 9:00-11:00
        TimeSlot::new(10, 1).unwrap(),  // 10:00-11:00 (重叠)
        TimeSlot::new(14, 3).unwrap(),  // 14:00-17:00
        TimeSlot::new(16, 2).unwrap(),  // 16:00-18:00 (重叠)
        TimeSlot::new(19, 2).unwrap(),  // 19:00-21:00
    ];
    
    println!("会议时间段冲突检测:");
    for (i, slot1) in time_slots.iter().enumerate() {
        println!("  时间段{}: {}", i + 1, slot1.format());
        
        for (j, slot2) in time_slots.iter().enumerate() {
            if i != j && slot1.overlaps(slot2) {
                println!("    ⚠️  与时间段{} 冲突: {}", j + 1, slot2.format());
            }
        }
    }
    
    // 6.2 游戏中的碰撞检测
    println!("\n6.2 游戏中的碰撞检测");
    
    #[derive(Debug, Clone, Copy)]
    struct GameObject {
        x: i32,
        y: i32,
        width: u32,
        height: u32,
    }
    
    impl GameObject {
        fn new(x: i32, y: i32, width: u32, height: u32) -> Self {
            GameObject { x, y, width, height }
        }
        
        fn right(&self) -> i32 {
            self.x + self.width as i32
        }
        
        fn bottom(&self) -> i32 {
            self.y + self.height as i32
        }
        
        fn collides_with(&self, other: &GameObject) -> bool {
            // AABB (轴对齐边界框) 碰撞检测
            self.x < other.right() && 
            self.right() > other.x &&
            self.y < other.bottom() &&
            self.bottom() > other.y
        }
        
        fn distance_to(&self, other: &GameObject) -> f32 {
            let center_x1 = self.x + (self.width / 2) as i32;
            let center_y1 = self.y + (self.height / 2) as i32;
            let center_x2 = other.x + (other.width / 2) as i32;
            let center_y2 = other.y + (other.height / 2) as i32;
            
            let dx = (center_x2 - center_x1) as f32;
            let dy = (center_y2 - center_y1) as f32;
            
            (dx * dx + dy * dy).sqrt()
        }
    }
    
    let game_objects = [
        GameObject::new(10, 10, 20, 20),    // 玩家
        GameObject::new(15, 15, 10, 10),    // 道具1 (与玩家重叠)
        GameObject::new(50, 20, 15, 15),    // 敌人1
        GameObject::new(100, 100, 30, 30),  // 敌人2
        GameObject::new(45, 25, 8, 8),      // 道具2 (与敌人1重叠)
    ];
    
    let names = ["玩家", "道具1", "敌人1", "敌人2", "道具2"];
    
    println!("游戏对象碰撞检测:");
    for (i, obj1) in game_objects.iter().enumerate() {
        println!("  {}: 位置({}, {}) 大小{}×{}", 
                names[i], obj1.x, obj1.y, obj1.width, obj1.height);
        
        for (j, obj2) in game_objects.iter().enumerate() {
            if i != j {
                let distance = obj1.distance_to(obj2);
                if obj1.collides_with(obj2) {
                    println!("    💥 与 {} 发生碰撞 (距离: {:.1})", names[j], distance);
                } else if distance < 50.0 {
                    println!("    🔍 {} 在附近 (距离: {:.1})", names[j], distance);
                }
            }
        }
    }
    
    // 6.3 数据分页系统
    println!("\n6.3 数据分页系统");
    
    struct PaginationInfo {
        total_items: usize,
        page_size: usize,
        current_page: usize,
    }
    
    impl PaginationInfo {
        fn new(total_items: usize, page_size: usize, current_page: usize) -> Result<Self, String> {
            if page_size == 0 {
                return Err("页面大小不能为0".to_string());
            }
            
            let max_page = (total_items + page_size - 1) / page_size;
            if current_page == 0 || (total_items > 0 && current_page > max_page) {
                return Err(format!("页面号超出范围 (1-{})", max_page));
            }
            
            Ok(PaginationInfo { total_items, page_size, current_page })
        }
        
        fn total_pages(&self) -> usize {
            if self.total_items == 0 { 0 } else { (self.total_items + self.page_size - 1) / self.page_size }
        }
        
        fn start_index(&self) -> usize {
            (self.current_page - 1) * self.page_size
        }
        
        fn end_index(&self) -> usize {
            (self.start_index() + self.page_size).min(self.total_items)
        }
        
        fn items_on_current_page(&self) -> usize {
            if self.start_index() >= self.total_items {
                0
            } else {
                self.end_index() - self.start_index()
            }
        }
        
        fn page_range(&self) -> std::ops::Range<usize> {
            self.start_index()..self.end_index()
        }
    }
    
    let data_sets = [
        (100, 10, 1),   // 100条数据，每页10条，第1页
        (100, 10, 5),   // 第5页
        (100, 10, 10),  // 第10页（最后一页）
        (95, 10, 10),   // 95条数据，第10页（只有5条）
        (0, 10, 1),     // 没有数据
    ];
    
    println!("数据分页系统:");
    for (total, page_size, page_num) in data_sets {
        match PaginationInfo::new(total, page_size, page_num) {
            Ok(pagination) => {
                println!("  数据集: {} 条，每页 {} 条，第 {} 页", total, page_size, page_num);
                println!("    总页数: {}", pagination.total_pages());
                println!("    当前页范围: {:?}", pagination.page_range());
                println!("    当前页项目数: {}", pagination.items_on_current_page());
                
                if pagination.total_pages() > 0 {
                    let progress = (page_num as f32 / pagination.total_pages() as f32) * 100.0;
                    println!("    进度: {:.1}%", progress);
                }
            },
            Err(error) => {
                println!("  数据集: {} 条，每页 {} 条，第 {} 页 → 错误: {}", 
                        total, page_size, page_num, error);
            }
        }
        println!();
    }
    
    // 6.4 温度控制系统
    println!("\n6.4 温度控制系统");
    
    #[derive(Debug)]
    struct TemperatureController {
        min_temp: f32,
        max_temp: f32,
        target_temp: f32,
        tolerance: f32,
    }
    
    impl TemperatureController {
        fn new(min_temp: f32, max_temp: f32, target_temp: f32, tolerance: f32) -> Result<Self, String> {
            if min_temp >= max_temp {
                return Err("最小温度必须小于最大温度".to_string());
            }
            if target_temp < min_temp || target_temp > max_temp {
                return Err("目标温度必须在允许范围内".to_string());
            }
            if tolerance <= 0.0 {
                return Err("容差必须大于0".to_string());
            }
            
            Ok(TemperatureController { min_temp, max_temp, target_temp, tolerance })
        }
        
        fn control_action(&self, current_temp: f32) -> &'static str {
            let lower_bound = self.target_temp - self.tolerance;
            let upper_bound = self.target_temp + self.tolerance;
            
            if current_temp < lower_bound {
                "加热"
            } else if current_temp > upper_bound {
                "冷却"
            } else {
                "保持"
            }
        }
        
        fn safety_check(&self, current_temp: f32) -> Result<(), String> {
            if current_temp < self.min_temp {
                Err(format!("温度过低: {:.1}°C < {:.1}°C", current_temp, self.min_temp))
            } else if current_temp > self.max_temp {
                Err(format!("温度过高: {:.1}°C > {:.1}°C", current_temp, self.max_temp))
            } else {
                Ok(())
            }
        }
        
        fn deviation(&self, current_temp: f32) -> f32 {
            (current_temp - self.target_temp).abs()
        }
    }
    
    let controller = TemperatureController::new(0.0, 100.0, 25.0, 2.0).unwrap();
    let temp_readings = [10.0, 22.5, 25.0, 27.5, 30.0, 95.0, 105.0];
    
    println!("温度控制系统 (目标: {:.1}°C ± {:.1}°C):", 
             controller.target_temp, controller.tolerance);
    
    for temp in temp_readings {
        let action = controller.control_action(temp);
        let deviation = controller.deviation(temp);
        
        print!("  当前温度: {:.1}°C → 动作: {} (偏差: {:.1}°C)", temp, action, deviation);
        
        match controller.safety_check(temp) {
            Ok(()) => println!(" ✅ 安全"),
            Err(error) => println!(" ⚠️  {}", error),
        }
    }
    
    println!("\n{}", "=".repeat(60));
}
